# -*- coding: utf-8 -*-
#
# Copyright (c) 2025 Huawei Technologies Co., Ltd.
# openUBMC is licensed under Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#         http://license.coscl.org.cn/MulanPSL2
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.

"""
节点渲染器

负责将 IR 节点渲染为 C++ 代码
"""

from typing import Dict, Any, TYPE_CHECKING, Optional, List

from ..ir import IRNode

if TYPE_CHECKING:
    from ..ir.module import IRModule
from ..ir.declarations.class_node import IRClassNode
from ..ir.declarations.method import IRMethodNode
from ..ir.declarations.property import IRPropertyNode
from ..ir.declarations.function import IRFunctionNode
from ..ir.declarations.enum import IREnumNode
from ..ir.statements.assignment import IRAssign
from ..ir.utilities import IRTemplate, IRRawText, IRGroupNode
from ..ir.expressions.basic import IRName
from ..symbol_meta import SymbolKind
from ..codegen.core.generator import get_global_generator
from ..codegen.core.context import CodeGenContext
from ..codegen.emitters.nested_function.struct_generator import (
    AsyncFunctionStructGenerator,
)
from ..codegen.emitters.nested_function.utils import get_functor_name
from ..codegen.emitters.nested_function_emitter import NestedFunctionEmitter

if TYPE_CHECKING:
    from ..ir.module import IRModule


class NodeRenderer:
    """节点渲染器"""

    def __init__(self, render_ctx: Dict[str, Any]):
        """初始化节点渲染器

        Args:
            render_ctx: 渲染上下文
        """
        self.render_ctx = render_ctx

    def render_nodes(self, nodes: list[IRNode], for_source: bool = False) -> str:
        """渲染节点列表

        Args:
            nodes: IR 节点列表
            for_source: 是否用于源文件（True 生成实现，False 生成声明）

        Returns:
            渲染后的代码
        """
        lines = []
        for node in nodes:
            code = self.render_node(node, for_source=for_source)
            if code:
                lines.append(code)
        return "\n".join(lines)

    def render_node(self, node: IRNode, for_source: bool = False) -> str:
        """渲染单个节点

        Args:
            node: IR 节点
            for_source: 是否用于源文件（True 生成实现，False 生成声明）

        Returns:
            渲染后的代码
        """
        # 如果节点有 render 方法，直接调用
        if hasattr(node, "render"):
            try:
                result = node.render(self.render_ctx)  # type: ignore
                if result:
                    return result.strip()
            except Exception:
                pass

        if isinstance(node, IRTemplate):
            return self._render_template_node(node)
        elif isinstance(node, IRRawText):
            return self._render_raw_text_node(node)
        elif isinstance(node, IRClassNode):
            if for_source:
                return self.render_class_impl(node)
            else:
                return self._render_class_decl(node)
        elif isinstance(node, IRFunctionNode):
            if for_source:
                return self.render_function_impl(node)
            else:
                return self._render_function_decl(node)
        elif isinstance(node, IREnumNode):
            return self._render_enum_decl(node)
        elif isinstance(node, IRAssign):
            if for_source:
                return self.render_global_variable_def(node)
            else:
                return self._render_global_variable_decl(node)
        elif isinstance(node, IRGroupNode):
            return self._render_group_node(node)

        return ""

    def _render_template_node(self, node: IRTemplate) -> str:
        """渲染模板节点

        Args:
            node: 模板节点

        Returns:
            渲染后的代码
        """
        # 优先使用 template_content 扩展参数
        template_content = node.get_extension_param("template_content")
        if template_content:
            # 处理简单的模板变量替换（如 ${node.name}）
            # 这里只处理简单的导出装饰器模板
            if node.context:
                for key, value in node.context.items():
                    if isinstance(value, object) and hasattr(value, "name"):
                        # 处理 NodeWrapper 等对象
                        template_content = template_content.replace(
                            f"${{{key}.name}}", getattr(value, "name", "")
                        )
                        template_content = template_content.replace(
                            f"${{{key}.export_macro}}",
                            getattr(value, "export_macro", "MC_EXPORT"),
                        )
            return template_content

        return ""

    def _render_raw_text_node(self, node: IRRawText) -> str:
        """渲染原始文本节点

        Args:
            node: 原始文本节点

        Returns:
            渲染后的代码
        """
        return node.text

    def _render_class_decl(
        self, node: IRClassNode, context: Optional[CodeGenContext] = None
    ) -> str:
        """渲染类声明

        Args:
            node: 类节点

        Returns:
            渲染后的代码
        """

        # 处理基类信息
        base_clause = ""
        if node.bases:
            base_names = []
            for base_name in node.bases:
                # 查找基类符号，检查是否有命名空间
                base_symbol = node.lookup_symbol(
                    base_name, symbol_kinds=[SymbolKind.CLASS]
                )
                if base_symbol and base_symbol.type_config:
                    # 从符号的 type_config 中获取命名空间（在导入时已保存）
                    namespace = base_symbol.type_config.get("namespace")
                    if namespace:
                        base_names.append(f"{namespace}::{base_name}")
                    else:
                        base_names.append(base_name)
                else:
                    # 没有符号或没有命名空间配置，直接使用基类名称
                    base_names.append(base_name)
            base_clause = " : public " + ", public ".join(base_names)

        lines = [f"class {node.name}{base_clause} {{"]

        # 渲染方法
        for access_mod in ["public", "protected", "private"]:
            methods = node.get_method_by_access_mod(access_mod)
            if methods:
                lines.append(f"{access_mod}:")
                for method in methods:
                    method_decl = self._render_method_decl(method)
                    if method_decl:
                        lines.append(f"    {method_decl}")

        # 渲染属性
        for access_mod in ["public", "protected", "private"]:
            props = node.get_propertie_by_access_mod(access_mod)
            if props:
                if not lines[-1].endswith("{"):
                    lines.append("")
                lines.append(f"{access_mod}:")
                for prop in props:
                    prop_decl = self._render_property_decl(prop)
                    if prop_decl:
                        lines.append(f"    {prop_decl}")

        lines.append("};")
        return "\n".join(lines)

    def _get_namespace_for_module(
        self, module_path: str, context: Optional[CodeGenContext] = None
    ) -> str:
        """获取模块的命名空间

        Args:
            module_path: 模块路径（如 "gtest.testing"）
            context: 代码生成上下文（可选）

        Returns:
            命名空间字符串，如果没有则返回空字符串
        """
        if not context or not context.ir_module:
            return ""

        # 使用命名空间映射（由 import_node 在解析时设置）
        imported_namespaces = context.ir_module.get_extension_param(
            "imported_module_namespaces"
        )
        if imported_namespaces:
            # 尝试直接匹配模块路径
            if module_path in imported_namespaces:
                return imported_namespaces[module_path]
            # 尝试匹配模块的最后一部分（如 "gtest.testing" -> "testing"）
            module_name = module_path.split(".")[-1]
            if module_name in imported_namespaces:
                return imported_namespaces[module_name]

        return ""

    def _render_method_decl(self, method: IRMethodNode) -> str:
        """渲染方法声明

        Args:
            method: 方法节点

        Returns:
            渲染后的代码
        """
        ret_value = method.get_cpp_return_type()
        if method.is_static:
            ret_value = "static " + ret_value
        if ret_value:
            ret_value += " "
        return (
            f"{ret_value}{method.get_cpp_method_name()}({method.format_cpp_params()});"
        )

    def _render_property_decl(self, prop: IRPropertyNode) -> str:
        """渲染属性声明

        Args:
            prop: 属性节点

        Returns:
            渲染后的代码
        """
        if prop.is_field:
            prop_type = prop.get_cpp_type()
        else:
            prop_type = f"static {prop.get_cpp_type()}"

        default_part = ""
        if prop.default_value:
            generator = get_global_generator()
            default_code = generator.generate_expression(prop.default_value)
            default_part = f" = {default_code}"

        return f"{prop_type} {prop.name}{default_part};"

    def _render_function_decl(self, node: IRFunctionNode) -> str:
        """渲染函数声明（简化版，不再处理嵌套函数）

        嵌套函数的处理由任务收集器统一管理。

        Args:
            node: 函数节点

        Returns:
            渲染后的代码
        """
        # 跳过 main 函数
        if node.get_extension_param("is_main_function"):
            return ""

        # 检查是否是嵌套函数
        parent = node.parent
        is_nested = False
        while parent:
            if isinstance(parent, IRFunctionNode):
                is_nested = True
                break
            parent = parent.parent

        # 嵌套函数的结构体定义已经在父函数生成时处理，不需要生成声明
        if is_nested:
            return ""

        # 异步函数使用特殊处理（会提取嵌套函数的结构体）
        if node.is_async:
            return self._render_async_struct_decl(node)

        # 对于非异步函数，也需要提取并输出嵌套函数的结构体
        result_parts = []
        ir_module = node.get_ir_module()
        if ir_module:
            # 先确保嵌套函数的结构体已经生成
            from ..codegen.emitters.nested_function.struct_generator import (
                AsyncFunctionStructGenerator,
            )
            from ..codegen.emitters.nested_function_emitter import (
                NestedFunctionEmitter,
            )

            # 收集嵌套函数
            nested_funcs = self._collect_nested_functions_in_order(node)

            # 为每个嵌套函数生成结构体（如果还没有生成）
            codegen_ctx = CodeGenContext(ir_module=ir_module)
            for nested_func in nested_funcs:
                # 递归处理嵌套函数内部的嵌套函数
                async_gen = AsyncFunctionStructGenerator()
                async_gen._generate_nested_function_structs_first(
                    nested_func, codegen_ctx
                )
                # 生成嵌套函数的结构体
                NestedFunctionEmitter.generate_struct_if_needed(
                    nested_func, codegen_ctx
                )

            # 获取嵌套函数的 functor 名称
            nested_functor_names = [
                get_functor_name(nested_func) for nested_func in nested_funcs
            ]

            # 从 lambda_structs 中提取属于该函数的嵌套函数结构体
            lambda_structs = ir_module.get_extension_param("lambda_structs") or []
            nested_structs = []
            remaining_structs = []
            used_structs = set()

            # 递归收集所有嵌套函数（包括嵌套函数的嵌套函数），保持正确的顺序
            all_nested_funcs = []
            visited = set()

            def collect_all_nested(func):
                if id(func) in visited:
                    return
                visited.add(id(func))
                # 先递归收集嵌套函数的嵌套函数（深度优先）
                nested_nested = self._collect_nested_functions_in_order(func)
                for nested_nested_func in nested_nested:
                    collect_all_nested(nested_nested_func)
                # 再添加当前函数（确保嵌套函数的嵌套函数在前面）
                all_nested_funcs.append(func)

            for nested_func in nested_funcs:
                collect_all_nested(nested_func)

            # 获取所有嵌套函数的 functor 名称（包括嵌套函数的嵌套函数）
            # 注意：all_nested_funcs 已经是深度优先的顺序（嵌套函数的嵌套函数在前面）
            all_nested_functor_names = [
                get_functor_name(nested_func) for nested_func in all_nested_funcs
            ]

            # 按照 all_nested_functor_names 的顺序提取结构体
            for nested_name in all_nested_functor_names:
                for struct in lambda_structs:
                    # 检查结构体代码中是否包含该嵌套函数的完整结构体定义
                    struct_stripped = struct.strip()
                    struct_starts_with_name = struct_stripped.startswith(
                        f"struct {nested_name}"
                    )
                    struct_starts_with_impl = struct_stripped.startswith(
                        f"struct {nested_name}_impl"
                    )
                    struct_contains_name_and_impl = (
                        nested_name in struct and "struct impl_type" in struct
                    )
                    if (
                        struct_starts_with_name
                        or struct_starts_with_impl
                        or struct_contains_name_and_impl
                    ) and struct not in used_structs:
                        nested_structs.append(struct)
                        used_structs.add(struct)
                        break

            # 将未使用的结构体保留在 lambda_structs 中
            for struct in lambda_structs:
                if struct not in used_structs:
                    remaining_structs.append(struct)

            # 更新 lambda_structs，移除已输出的嵌套函数结构体
            if nested_structs:
                ir_module.set_extension_param(
                    "lambda_structs", remaining_structs, replace_existing=True
                )

            # 先输出嵌套函数的结构体，再输出函数声明
            for nested_struct in nested_structs:
                result_parts.append(nested_struct)
                if not nested_struct.endswith("\n"):
                    result_parts.append("")

        # 普通函数声明
        template_prefix = self._get_template_prefix(node)
        return_type = node.get_cpp_return_type()
        params = node.format_cpp_params()
        decl = f"{template_prefix}{return_type} {node.name}({params});"
        result_parts.append(decl)

        return "\n\n".join(result_parts)

    def _collect_nested_functions_in_order(
        self, parent_func: IRFunctionNode
    ) -> List[IRFunctionNode]:
        """收集函数内部的嵌套函数，按源码顺序排序

        Args:
            parent_func: 父函数

        Returns:
            嵌套函数列表（按源码行号排序）
        """
        nested_funcs = []

        if not parent_func.body:
            return nested_funcs

        # 递归遍历函数体
        def collect_from_stmt(stmt):
            if isinstance(stmt, IRFunctionNode):
                # 检查是否是直接嵌套函数
                if self._is_direct_nested_of(stmt, parent_func):
                    nested_funcs.append(stmt)
            elif hasattr(stmt, "statements"):
                for child_stmt in stmt.statements:
                    collect_from_stmt(child_stmt)
            elif hasattr(stmt, "get_child_nodes"):
                for child in stmt.get_child_nodes():
                    collect_from_stmt(child)
            elif hasattr(stmt, "__dict__"):
                # 遍历所有属性
                for attr_value in stmt.__dict__.values():
                    if isinstance(attr_value, IRNode):
                        collect_from_stmt(attr_value)
                    elif isinstance(attr_value, list):
                        for item in attr_value:
                            if isinstance(item, IRNode):
                                collect_from_stmt(item)

        if hasattr(parent_func.body, "statements"):
            for stmt in parent_func.body.statements:
                collect_from_stmt(stmt)

        # 按源码行号排序
        nested_funcs.sort(
            key=lambda f: (
                f.source_line if hasattr(f, "source_line") and f.source_line > 0 else 0
            )
        )

        return nested_funcs

    def _is_direct_nested_of(
        self, nested_func: IRFunctionNode, parent_func: IRFunctionNode
    ) -> bool:
        """检查 nested_func 是否是 parent_func 的直接嵌套函数

        Args:
            nested_func: 嵌套函数
            parent_func: 父函数

        Returns:
            如果是直接嵌套函数则返回 True
        """
        parent = nested_func.parent
        while parent:
            if parent == parent_func:
                return True
            if isinstance(parent, IRFunctionNode):
                return False  # 是其他函数的嵌套函数
            parent = parent.parent
        return False

    def _get_template_prefix(self, node: IRFunctionNode) -> str:
        """获取函数的模板前缀（如果是模板函数）

        Args:
            node: 函数节点

        Returns:
            模板前缀字符串
        """
        symbol = node.get_symbol(create_if_not_exists=True)
        if not symbol or not symbol.signatures:
            return ""

        signature = symbol.signatures[0]
        if not signature.template_params:
            return ""

        template_params_str = ", ".join(
            f"typename {param}" for param in signature.template_params
        )
        return f"template<{template_params_str}>\n"

    def _render_async_struct_decl(self, node: IRFunctionNode) -> str:
        """渲染异步函数结构体声明

        Args:
            node: 异步函数节点

        Returns:
            渲染后的代码
        """

        # 创建上下文
        ir_module = node.get_ir_module()
        if ir_module is None:
            return ""
        codegen_ctx = CodeGenContext(ir_module=ir_module)

        # 生成 struct 名称：全局函数使用函数名本身
        generator = AsyncFunctionStructGenerator()
        struct_code = generator.generate(node, codegen_ctx)

        # 在生成父函数结构体之前，先输出属于该函数的嵌套函数的结构体
        parent_functor_name = get_functor_name(node)
        parent_nested_map = (
            ir_module.get_extension_param("_parent_nested_functions") or {}
        )
        nested_functor_names = parent_nested_map.get(parent_functor_name, [])

        # 从 lambda_structs 中提取属于该函数的嵌套函数结构体
        # 按照 nested_functor_names 的顺序提取，确保定义顺序正确
        lambda_structs = ir_module.get_extension_param("lambda_structs") or []
        nested_structs = []
        remaining_structs = []
        used_structs = set()  # 记录已使用的结构体，避免重复

        # 按照 nested_functor_names 的顺序提取结构体
        for nested_name in nested_functor_names:
            for struct in lambda_structs:
                # 检查结构体代码中是否包含该嵌套函数的完整结构体定义
                # 注意：现在内层结构体直接命名为 impl_type，不再使用 {nested_name}_impl
                if (
                    f"struct {nested_name}" in struct
                    or f"struct {nested_name}_impl" in struct
                    or (
                        f"struct {nested_name}" in struct
                        and "struct impl_type" in struct
                    )
                ) and struct not in used_structs:
                    nested_structs.append(struct)
                    used_structs.add(struct)
                    break

        # 将未使用的结构体保留在 lambda_structs 中
        for struct in lambda_structs:
            if struct not in used_structs:
                remaining_structs.append(struct)

        # 更新 lambda_structs，移除已输出的嵌套函数结构体
        if nested_structs:
            ir_module.set_extension_param(
                "lambda_structs", remaining_structs, replace_existing=True
            )

        # 组合嵌套结构体和主结构体
        result_parts = []
        for nested_struct in nested_structs:
            result_parts.append(nested_struct)
            if not nested_struct.endswith("\n"):
                result_parts.append("")
        result_parts.append(struct_code)

        return "\n".join(result_parts)

    def _render_enum_decl(self, node: IREnumNode) -> str:
        """渲染枚举声明

        Args:
            node: 枚举节点

        Returns:
            渲染后的代码
        """
        lines = [f"enum class {node.name} {{"]
        for member in node.members:
            member_name = member.name
            lines.append(f"    {member_name},")
        lines.append("};")
        return "\n".join(lines)

    def _render_global_variable_decl(self, node: IRAssign) -> str:
        """渲染全局变量声明

        Args:
            node: 赋值节点（全局变量）

        Returns:
            渲染后的代码
        """
        # 检查是否是变量声明（模块级别的赋值）
        is_declaration = node.get_extension_param("is_variable_declaration", False)
        if not is_declaration:
            return ""  # 不是声明，跳过

        # 获取目标变量
        if not node.target_exprs:
            return ""

        target = node.target_exprs[0]
        if not isinstance(target, IRName):
            return ""  # 只处理简单变量

        var_name = target.id

        # 获取 C++ 类型
        cpp_type = node.get_extension_param("cpp_type", "")
        if not cpp_type:
            return ""  # 没有类型信息，跳过

        # 生成 extern 声明
        return f"extern {cpp_type} {var_name};"

    def _render_group_node(self, node: IRGroupNode) -> str:
        """渲染组节点

        Args:
            node: 组节点

        Returns:
            渲染后的代码
        """
        for_source = self.render_ctx.get("type") == "source"
        if node.tag == "namespace":
            return self._render_namespace_node(node)
        else:
            return self.render_nodes(node.nodes, for_source=for_source)

    def _render_namespace_node(self, node: IRGroupNode) -> str:
        """渲染命名空间节点

        Args:
            node: 命名空间节点

        Returns:
            渲染后的代码
        """
        for_source = self.render_ctx.get("type") == "source"
        namespace_name = node.params.get("namespace", "unknown")
        content = self.render_nodes(node.nodes, for_source=for_source)
        return f"namespace {namespace_name} {{\n{content}\n}}"

    def render_function_impl(self, node: IRFunctionNode) -> str:
        """渲染函数实现（简化版，不再处理嵌套函数）

        嵌套函数的处理由任务收集器统一管理。

        Args:
            node: 函数节点

        Returns:
            渲染后的代码
        """
        # 检查是否是嵌套函数
        parent = node.parent
        is_nested = False
        while parent:
            if isinstance(parent, IRFunctionNode):
                is_nested = True
                break
            parent = parent.parent

        # 对于嵌套函数：
        # - 异步函数且有 await：生成 execute 方法实现
        # - 非异步函数：不需要生成函数体（结构体已经在头文件中定义）
        if is_nested:
            if node.is_async:
                has_await = node.get_extension_param("has_await_expressions", False)
                if has_await:
                    ir_module = node.get_ir_module()
                    if ir_module is None:
                        return ""
                    codegen_ctx = CodeGenContext(ir_module=ir_module)
                    generator = AsyncFunctionStructGenerator()
                    return generator.generate_execute_impl(node, codegen_ctx)
            # 非异步嵌套函数不需要生成函数体
            return ""

        # 对于全局函数：正常生成实现
        if node.is_async:
            has_await = node.get_extension_param("has_await_expressions", False)
            if has_await:
                ir_module = node.get_ir_module()
                if ir_module is None:
                    return ""
                codegen_ctx = CodeGenContext(ir_module=ir_module)
                generator = AsyncFunctionStructGenerator()
                return generator.generate_execute_impl(node, codegen_ctx)
            else:
                # 没有 await 的异步函数，使用普通函数处理
                ir_module = node.get_ir_module()
                generator = get_global_generator()
                codegen_ctx = CodeGenContext(
                    ir_module=ir_module,
                    current_function=node.name,
                )
                if node.body is None:
                    return ""
                function_body = generator.generate_statements(
                    node.body.statements,
                    return_type=node.get_cpp_return_type(),
                    context=codegen_ctx,
                )
                template_prefix = self._get_template_prefix(node)
                return_type = node.get_cpp_return_type()
                params = node.format_cpp_params()
                return f"{template_prefix}{return_type} {node.name}({params}) {{\n    {function_body}\n}}"

        # 普通函数
        ir_module = node.get_ir_module()
        generator = get_global_generator()
        codegen_ctx = CodeGenContext(
            ir_module=ir_module,
            current_function=node.name,
        )
        if node.body is None:
            return ""
        function_body = generator.generate_statements(
            node.body.statements,
            return_type=node.get_cpp_return_type(),
            context=codegen_ctx,
        )

        template_prefix = self._get_template_prefix(node)
        return_type = node.get_cpp_return_type()
        params = node.format_cpp_params()

        return f"{template_prefix}{return_type} {node.name}({params}) {{\n    {function_body}\n}}"

    def render_class_impl(self, node: IRClassNode) -> str:
        """渲染类实现

        Args:
            node: 类节点

        Returns:
            渲染后的代码
        """
        generator = get_global_generator()
        ir_module = node.get_ir_module()

        lines = []
        for method in node.methods:
            codegen_ctx = CodeGenContext(
                ir_module=ir_module,
                current_function=method.name,
            )
            if method.body is None:
                continue
            method_body = generator.generate_statements(
                method.body.statements,
                return_type=method.get_cpp_return_type(),
                context=codegen_ctx,
            )

            return_type = method.get_cpp_return_type()
            method_name = method.get_cpp_method_name()
            params = method.format_cpp_params()

            lines.append(
                f"{return_type} {node.name}::{method_name}({params}) {{\n    {method_body}\n}}"
            )

        return "\n".join(lines)

    def render_global_variable_def(self, node: IRAssign) -> str:
        """渲染全局变量定义

        Args:
            node: 赋值节点（全局变量）

        Returns:
            渲染后的代码
        """
        # 检查是否是变量声明（模块级别的赋值）
        is_declaration = node.get_extension_param("is_variable_declaration", False)
        if not is_declaration:
            return ""  # 不是声明，跳过

        # 获取目标变量
        if not node.target_exprs:
            return ""

        target = node.target_exprs[0]
        if not isinstance(target, IRName):
            return ""  # 只处理简单变量

        var_name = target.id

        # 获取 C++ 类型
        cpp_type = node.get_extension_param("cpp_type", "")
        if not cpp_type:
            return ""  # 没有类型信息，跳过

        # 生成初始值代码
        generator = get_global_generator()
        gen_ctx = CodeGenContext(current_node=node)

        # 生成初始值
        if node.value is None:
            return ""
        value_code = generator.generate_expression(node.value, gen_ctx)

        # 生成定义
        return f"{cpp_type} {var_name} = {value_code};"

    def _collect_nested_execute_impls(self, ir_module) -> str:
        """收集所有嵌套函数的 execute 方法实现

        Args:
            ir_module: IR 模块

        Returns:
            所有嵌套函数 execute 方法实现的代码
        """
        # 获取所有函数节点（包括嵌套函数）
        all_functions = []
        for node in ir_module.nodes:
            all_functions.extend(self._collect_all_functions(node))

        # 为每个嵌套函数生成 execute 方法实现
        codegen_ctx = CodeGenContext(ir_module=ir_module)
        generator = AsyncFunctionStructGenerator()
        impl_parts = []

        for func_node in all_functions:
            # 只处理异步函数且有 await 的函数
            if not func_node.is_async:
                continue

            has_await = func_node.get_extension_param("has_await_expressions", False)
            if not has_await:
                continue

            # 检查是否是嵌套函数（有父函数节点）
            parent = func_node.parent
            is_nested = False
            while parent:
                if isinstance(parent, IRFunctionNode):
                    is_nested = True
                    break
                parent = parent.parent

            # 如果是嵌套函数，生成 execute 方法实现
            if is_nested:
                execute_impl = generator.generate_execute_impl(func_node, codegen_ctx)
                if execute_impl:
                    impl_parts.append(execute_impl)

        return "\n\n".join(impl_parts)

    def _collect_all_functions(self, node: IRNode) -> list:
        """递归收集所有函数节点（包括嵌套函数）

        Args:
            node: IR 节点

        Returns:
            函数节点列表
        """
        functions = []
        if isinstance(node, IRFunctionNode):
            functions.append(node)
            # 递归收集函数体内的嵌套函数
            if node.body and hasattr(node.body, "statements"):
                for stmt in node.body.statements:
                    functions.extend(self._collect_all_functions(stmt))
        elif hasattr(node, "get_child_nodes"):
            for child in node.get_child_nodes():
                functions.extend(self._collect_all_functions(child))
        elif hasattr(node, "statements"):
            # 使用 getattr 安全访问
            statements = getattr(node, "statements", [])
            for stmt in statements:
                functions.extend(self._collect_all_functions(stmt))

        return functions
